import Vue from 'vue';

import '@/main.js';
import '@/assets/fonts/iconfont.css';
import './index.scss';

import { country, china, fieldList, industryList, unitList } from '@/assets/js/country-select'

new Vue({
  el: '#lodash',
  data() {
    return {
      msg: '这里是lodash页面'
    }
  },
  mounted() {
  },
  methods: {
    /**
     * 功能：将数组（array）拆分成多个 size 长度的区块，并将这些区块组成一个新数组
     * 是否修改原数组：false
     * 深拷贝：false
     */
    handleChunk() {
      let res = _.chunk(unitList, 2);
      console.log(res);
    },

    /**
     * 创建一个新数组，包含原数组中所有的非假值元素。例如false, null,0, "", undefined, 和 NaN 都是被认为是“假值”。
     * 注意点:这个方法只能识别数组中存放的简单数据对象,复杂数据对象都视为真值
     * 是否修改原数组：false
     */
    handleCompact() {
      let arr = [0, 1, false, 2, '', 3, {}];
      let res = _.compact(arr);
      console.log(res);
    },

    /**
     * 创建一个新数组，将array与任何数组 或 值连接在一起。
     * 是否修改原数组：false
     * 深拷贝：false
     */
    handleConcat() {
      let res = _.concat(unitList, industryList);
      console.log(res);
      res[0].label = 996
      console.log(unitList);
    },

    /**
     * 使用 value 值来填充（替换） array，从start位置开始, 到end位置结束（但不包含end位置）。
     * 是否修改原数组：true
     */
    handleFill() {
      let arr = [1, 2, 3];
      _.fill(arr, 'a');
      console.log(arr);

      let arr1 = [4, 6, 8, 10];
      _.fill(arr1, '*', 1, 3);
      console.log(arr1);
    },

    /**
     * 创建一个具有唯一array值的数组，每个值不包含在其他给定的数组中。
     * 注意点:这个方法只能识别数组中存放的简单数据对象,复杂数据对象都视为不包含
     * 是否修改原数组：false
     */
    handleDifference() {
      let res = _.difference([{ name: '形成' }, { name: '形成1' }, 3, 2, 1], [{ name: '形成' }, 4, 2]);
      console.log(res);
    },

    /**
     * 这个方法类似_.difference ，除了它接受一个 iteratee （注：迭代器）， 调用array 和 values 中的每个元素以产生比较的标准。
     * 深拷贝：false
     * 是否修改原数组：false
     */
    handleDifferenceBy() {
      _.differenceBy([3.1, 2.2, 1.3], [4.4, 2.5], Math.floor);//[3.1,1.3]
      let arr = [{ name: '形成' }, { name: '形成1' }];
      let arr1 = [{ name: '形成' }];
      let res = _.differenceBy(arr, arr1, 'name');
      console.log(arr, arr1, res);
      res[0].name = 996;
    },

    /**
     * 这个方法类似_.difference ，除了它接受一个 comparator （注：比较器），它调用比较array，values中的元素
     * 深拷贝：false
     * 是否修改原数组：false
     */
    handleDifferenceWith() {
      let arr = [{ name: '形成', age: 26 }, { name: '形成1', age: 26 }];
      let arr1 = [{ name: '形成', age: 26 }];
      let res = _.differenceWith(arr, arr1, _.isEqual);
      console.log(arr, arr1, res);
      res[0].name = 996;
    },

    /**
     * 创建一个切片数组，去除array前面的n个元素。（n默认值为1。）
     * 深拷贝：false
     * 是否修改原数组：false
     */
    handleDrop() {
      let res = _.drop(unitList);
      let res1 = _.drop(unitList, 2);
      let res2 = _.drop(unitList, 0);
      console.log(res, res1, res2);
    },

    /**
     * 创建一个切片数组，去除array尾部的n个元素。（n默认值为1。）
     * 深拷贝：false
     * 是否修改原数组：false
     */
    handleDropRight() {
      let res = _.dropRight(unitList);
      let res1 = _.dropRight(unitList, 2);
      let res2 = _.dropRight(unitList, 0);
      console.log(res, res1, res2);
    },

    /**
     * 创建一个切片数组，去除array中从 predicate 返回假值开始到尾部的部分
     * 个人理解：从数组尾部开始寻找，遇到第一个不符合条件的数组就停止，并slice(0,'第一个不符合条件的数组的索引')
     * 从右侧开始，开始索引到返回值为false时对应的索引
     * 深拷贝：false
     * 是否修改原数组：false
     */
    handleDropRightWhile() {
      let users = [
        { 'user': 'barney1', 'active': false },
        { 'user': 'barney2', 'active': true },
        { 'user': 'fred', 'active': true },
        { 'user': 'pebbles', 'active': false }
      ];
      let res = _.dropRightWhile(users, function (o) { return !o.active; });
      console.log(res);
    },

    /**
     * 从左侧开始，开始索引到返回值为false时对应的索引
     * 深拷贝：false
     * 是否修改原数组：false
     */
    handleDropWhile() {
      let users = [
        { 'user': 'barney1', 'active': false },
        { 'user': 'barney2', 'active': true },
        { 'user': 'fred', 'active': true },
        { 'user': 'pebbles', 'active': false }
      ];
      let res = _.dropWhile(users, function (o) { return !o.active; });
      console.log(res);
    }
  }
})